home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1995 April / Internet Tools.iso / applic / ncsa / Mac / Telnet2.6 / prerelease / d4 / Telnet2.6.1d4.src.sit.hqx / Telnet 2.6.1d4 source / source / tek / tekrgmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-18  |  12.4 KB  |  596 lines
  1. /*
  2. rgmac.c by Gaige B. Paulsen
  3.   spawned from rgp.c by Aaron Contorer for NCSA
  4. Copyright 1987, board of trustees, University of Illinois
  5.  
  6. Routines for Macintosh Window output.  
  7. */
  8.  
  9. #ifdef MPW
  10. #pragma segment TEKMAIN
  11. #endif
  12.  
  13. #include <stdio.h>
  14. #include <String.h>
  15. #include <Packages.h>
  16.  
  17. #include "tekrgmac.proto.h"
  18. #include "TelnetHeader.h"
  19. #include "maclook.proto.h"
  20. #include "vgtek.proto.h"
  21. #include "mydnr.proto.h"
  22. #include "rsmac.proto.h"
  23. #include "netevent.proto.h"
  24. #include "rg0.proto.h"
  25. #include "rgmp.proto.h"
  26. #include "InternalEvents.h"
  27. #include "tekdefs.h"        /* NCSA: sb - all the TEK defines are now here */
  28.  
  29. //#define TEK_DEBUG1
  30. #ifdef    TEK_DEBUG1
  31. #include "debug.h"
  32. #define    TEK_DEBUG_PRINT(x)    putln(x)
  33. char    TEK_DEBUG_STRING    [512];
  34. #else
  35. #define    TEK_DEBUG_PRINT(x)
  36. #endif
  37.  
  38. /*--------------------------------------------------------------------------*/
  39. /* Some variable definitions are needed before we give the code                */
  40. /*                                                                             */
  41. /*--------------------------------------------------------------------------*/
  42.  
  43. long    RGMlastclick;
  44. short    RGMcolor[]=
  45.     { 30,            /* black */
  46.       33,            /* white */
  47.       205,            /* red */
  48.       341,            /* green */
  49.       409,            /* blue */
  50.       273,            /* cyan */
  51.       137,            /* magenta */
  52.       69            /* yellow */
  53.       };
  54.  
  55. struct    RGMwindows *RGMwind[ MAXWIND ];
  56.  
  57. char    *RGMdevname(void)
  58. {
  59.     return("Macintosh Windows");
  60. }
  61.  
  62. short    RGMnewwin(void)
  63. {
  64.     short    i = 0;
  65.  
  66.     while ((i < MAXWIND) && (RGMwind[i] != nil)) i++;
  67.  
  68.     if (i >= MAXWIND) return(-1);
  69.  
  70.     RGMwind[i] = (struct RGMwindows *) NewPtrClear(sizeof(struct RGMwindows));
  71.     if (RGMwind[i] == nil) {
  72.         return -1;
  73.         }
  74.  
  75.     RGMwind[i]->id = 'RGMW';
  76.  
  77.     RGMwind[i]->wind = GetNewWindow(256, NULL, kInFront);
  78.     if (RGMwind[i]->wind == 0L) {
  79.         DisposePtr((Ptr)RGMwind[i]);
  80.         RGMwind[i] = nil;
  81.         return -1;
  82.         }
  83.  
  84.     ((WindowPeek)RGMwind[i]->wind)->windowKind = WIN_TEK;
  85.     
  86.     RGMwind[i]->vg = -1;                /* BYU */
  87.     RGMwind[i]->vs = -1;                /* BYU */
  88.     RGMwind[i]->xorigin = 0;
  89.     RGMwind[i]->yorigin = 0;
  90.     RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  91.     RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  92.     RGMwind[i]->width   = 400;        /* BYU LSC - was 256 (size of old window resource */
  93.     RGMwind[i]->height  = 300;        /* BYU LSC - was 342 (size of old window resource */
  94.     RGMwind[i]->ingin   = 0;        /* BYU LSC */
  95.  
  96.     ValidRect(&RGMwind[i]->wind->portRect);  
  97.  
  98.     return(i);
  99. }
  100.  
  101. void    RGMinit(void)
  102. {
  103.     short    i;
  104.     for (i = 0; i < MAXWIND; i++)
  105.         RGMwind[i] = nil;
  106. }
  107.  
  108. short    RGMgin(short w)
  109. {
  110.     if (RGsetwind(w)) return(-1);
  111.  
  112.     setgraphcurs();
  113.     RGMwind[w]->ingin=1;
  114. }
  115.  
  116. short    RGMpencolor(short w, short color)
  117. {
  118.     if (RGsetwind(w) ) return(-1);
  119.     ForeColor((long) RGMcolor[color] );
  120. #ifdef    TEK_DEBUG_1
  121.     sprintf(TEK_DEBUG_STRING, "TEK: Setting pen color to %d", color);
  122.     putln(TEK_DEBUG_STRING);
  123. #endif
  124.  
  125. }
  126.  
  127. short    RGMclrscr(short w)
  128. {    
  129.     if (RGsetwind(w) ) return(-1);
  130.     PaintRect(&RGMwind[w]->wind->portRect);
  131.     TEK_DEBUG_PRINT("TEK: Clearing screen");                    
  132. }    
  133.  
  134. short    RGMclose(short w)
  135. {
  136.     if (RGsetwind(w) ) return(-1);
  137.  
  138.     DisposeWindow(RGMwind[w]->wind);
  139.     DisposePtr((Ptr)RGMwind[w]->name);
  140.     DisposePtr((Ptr)RGMwind[w]);
  141.     RGMwind[w] = nil;
  142. }
  143.  
  144. short    RGMpoint(short w, short x, short y)
  145. {
  146.     if (RGsetwind(w) ) return(-1);
  147.  
  148.     MoveTo(x,y);
  149.     LineTo(x,y);
  150. } 
  151.  
  152. short    RGMdrawline(short w, short x0, short y0, short x1, short y1)
  153. {
  154.     long    xl0, yl0, xl1, yl1;
  155.     
  156.     if (RGsetwind(w) )
  157.         return(-1);
  158.  
  159.     xl0 = ((long)x0 * RGMwind[w]->width) / INXMAX;
  160.     yl0 = (long)RGMwind[w]->height - (((long)y0 * RGMwind[w]->height) / INYMAX);
  161.     xl1 = ((long)x1 * RGMwind[w]->width) / INXMAX;
  162.     yl1 = (long)RGMwind[w]->height - (((long)y1 * RGMwind[w]->height) / INYMAX);
  163.  
  164.     MoveTo((short)xl0, (short)yl0);
  165.     LineTo((short)xl1, (short)yl1);
  166. }
  167.  
  168. void    RGMinfo(short w, short v, short a, short b, short c, short d)
  169. {
  170.     UNUSED_ARG(a)
  171.     UNUSED_ARG(b)
  172.     UNUSED_ARG(c)
  173.     UNUSED_ARG(d)
  174.     RGMwind[w]->vg=v;
  175. }
  176.  
  177. void    RGMpagedone(short w)
  178. {
  179.     UNUSED_ARG(w)
  180. }
  181.  
  182. void    RGMdataline(short w, short data, short count)
  183. {
  184.     UNUSED_ARG(w)
  185.     UNUSED_ARG(data)
  186.     UNUSED_ARG(count)
  187. }
  188.  
  189.  
  190. void    RGMcharmode(short w, short rotation, short size)
  191. {
  192.     UNUSED_ARG(w)
  193.     UNUSED_ARG(rotation)
  194.     UNUSED_ARG(size)
  195. }
  196.  
  197. void    RGMgmode(void)
  198. {}
  199.  
  200. void    RGMtmode(void)
  201. {}
  202.  
  203. void    RGMshowcur(void)
  204. {
  205. }
  206.  
  207. void    RGMlockcur(void)
  208. {
  209. }
  210.  
  211. void    RGMhidecur(void)
  212. {
  213. }
  214.  
  215. void    RGMbell(short w)
  216. {
  217.     UNUSED_ARG(w)
  218. }
  219.  
  220. void    RGMuncover(short w)
  221. {
  222.     UNUSED_ARG(w)
  223. }
  224.  
  225. short    RGMoutfunc(short (*f )())
  226. {
  227.     UNUSED_ARG(f)
  228.     return(0);    // Unused
  229. }
  230.  
  231. short    RGsetwind(short dnum)
  232. {
  233.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  234.  
  235.     if (RGMwind[dnum] == nil) return -1;
  236.  
  237.     SetPort( RGMwind[dnum]->wind);
  238.     return(0);
  239. }
  240.  
  241. short    RGfindbyVG(short vg)
  242. {
  243.     short    i = 0;
  244.     
  245.     while (i < MAXWIND) {
  246.         if (RGMwind[i] != nil) {
  247.             if (RGMwind[i]->vg == vg)
  248.                 break;
  249.             }
  250.         i++;
  251.         }
  252.  
  253.     if (i >= MAXWIND) return(-1);
  254.     return(i);
  255. }
  256.  
  257. short    RGattach(short vg, short virt, char *name, short TEKtype)
  258. {
  259.     short            dnum;
  260.     unsigned long    time;
  261.     char            myname[256],ts[256];
  262.  
  263.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);
  264.  
  265.     RGMwind[dnum]->vs = virt;
  266.     RGMwind[dnum]->name = (unsigned char *) NewPtrClear((long) 256);        /* BYU LSC */
  267.  
  268.     if (RGMwind[dnum]->name == 0L) return(-2);
  269.  
  270.     myname[0] = 'Ñ';
  271.     if (TEKtype)
  272.         strcpy(&myname[1], "[4105] ");
  273.     else
  274.         strcpy(&myname[1], "[4014] ");
  275.         
  276.     strncpy(&myname[strlen(myname)],name,120);
  277.  
  278.     GetDateTime(&time);
  279.     IUTimeString(time,FALSE,(StringPtr) ts);        /* BYU LSC - Put time in the temp string */
  280.     p2cstr((StringPtr)ts);                                            /* BYU LSC */
  281.  
  282.     strncat(myname,"  ",2);                /* BYU - was 4 - Space, please */
  283.     strncat(myname,ts,64);                /* BYU - Place the time string at the end */
  284.     strcpy((char *) RGMwind[dnum]->name,myname);    /* BYU LSC */
  285.  
  286.     if (RGMwind[dnum]->wind != (GrafPtr) 0) {    /* BYU LSC */
  287.         c2pstr(myname);                            /* BYU LSC */
  288.         SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);    /* BYU LSC */
  289.     }
  290.  
  291.     return(0);
  292. }
  293.  
  294.  
  295. short    RGdetach( short vg)
  296. {
  297.         short    dnum;            /* BYU */
  298.         char    myname[256];            /* BYU LSC */
  299.  
  300.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);        /* BYU */
  301.     if (dnum >= MAXWIND)  return(-1);                    /* BYU */
  302.  
  303.     if (RGMwind[dnum]->vs != -1) {                                     /* BYU */
  304.         if (RGMwind[dnum]->wind != (GrafPtr) 0) {                    /* BYU */
  305. #if 1
  306.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  307.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  308.             strncpy(myname, (char *) RGMwind[dnum]->name,256);    /* BYU LSC */
  309.             c2pstr(myname);                                        /* BYU LSC */
  310.             SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);                /* BYU LSC */
  311. #else
  312.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  313.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  314.             SetWTitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);    /* BYU LSC */
  315. #endif
  316.         }                            /* BYU */
  317.     }                                /* BYU */
  318.     return(0);                        /* BYU */
  319. }
  320.  
  321. short    RGfindbywind( GrafPtr wind)
  322. {
  323.     short    i = 0;
  324.  
  325.     while (i < MAXWIND) {
  326.         if (RGMwind[i] != nil) {
  327.             if (RGMwind[i]->wind == wind)
  328.                 break;
  329.             }
  330.         i++;
  331.         }
  332.  
  333.     if (i >= MAXWIND) return(-1);
  334.     return(i);
  335. }
  336.  
  337. short    RGupdate( GrafPtr wind)
  338. {
  339.     short    i = 0,
  340.             done;
  341.  
  342.     if ((i = RGfindbywind(wind)) < 0)
  343.         return(-1);
  344.  
  345.     SetPort(wind);
  346.     BeginUpdate(wind);
  347.  
  348.     VGstopred(RGMwind[i]->vg);
  349.     VGpage(RGMwind[i]->vg);
  350.     done = VGpred(RGMwind[i]->vg,RGMwind[i]->vg);
  351.  
  352.     EndUpdate(wind);
  353.     if (!done)
  354.         netputevent(USERCLASS,RG_REDRAW,RGMwind[i]->vg,0);
  355.     return(done);
  356. }
  357.  
  358. short    RGsupdate( short i)
  359. {
  360.     short    rg;
  361.  
  362.     rg = RGfindbyVG(i);
  363.  
  364.     if (rg < 0) return(0);
  365.     SetPort(RGMwind[rg]->wind);
  366.     if (!VGpred(RGMwind[rg]->vg,RGMwind[rg]->vg))
  367.     {
  368.         netputevent(USERCLASS,RG_REDRAW,i,0);
  369.     }
  370.     else
  371.         return(1);
  372.     return(0);
  373. }
  374.  
  375. short    RGgetVG(GrafPtr wind)
  376. {
  377.     short    i;
  378.  
  379.     i = RGfindbywind(wind);
  380.  
  381.     return(RGMwind[i]->vg);
  382. }
  383.  
  384. short    RGgetdnum(GrafPtr wind)
  385. {
  386.     return(RGfindbywind(wind));
  387. }
  388.  
  389. short    RGgetVS(short dnum)
  390. {
  391.     return(RGMwind[dnum]->vs);
  392. }
  393.  
  394. short    inSplash(Point *p1, Point *p2)
  395. {
  396.     if ((p1->h - p2->h > 3) || (p2->h - p1->h > 3))
  397.         return(0);
  398.     if ((p1->v - p2->v > 3) || (p2->v - p1->v > 3))
  399.         return(0);
  400.  
  401.     return(1);
  402. }
  403.  
  404. void VidSync( void)
  405. {
  406.     long    a;
  407.     a = TickCount();            /* BYU LSC */
  408.     while (a == TickCount())
  409.         /* loop*/;    /* BYU LSC */
  410. }
  411.  
  412. void RGmousedown
  413.   (
  414.     GrafPtr wind,
  415.     Point *wherein
  416.   )
  417. {
  418.     unsigned long    lx,ly;        /* NCSA: SB */
  419.     char            thispaceforent[6];
  420.     short            i;
  421.     Point            where;
  422.     char            dum[32];
  423.  
  424.     where = *wherein;
  425.     if ((i = RGfindbywind(wind)) < 0)
  426.         return;
  427.  
  428.     if (!RGMwind[i]->ingin)
  429.     {
  430.     Point    anchor,current,last;
  431. #if 0                            /* BYU LSC - was "#ifndef MPW" */
  432.     long    TickCount();
  433. #endif MPW
  434.     long    tc;
  435.     short    x0,y0,x1,y1;
  436.     Rect    rect;
  437.     
  438.         SetPort(wind);
  439.     
  440.         last  = where;
  441.         current = where;
  442.         anchor = where;
  443.     
  444.         PenPat(PATTERN(qd.gray));    
  445.         PenMode(patXor);
  446.     
  447.         SetRect(&rect,0,0,0,0);
  448.     
  449.         while (StillDown())
  450.         {
  451.             GetMouse(¤t);
  452.             if (inSplash(¤t,&anchor)) continue;
  453.             tc = TickCount();
  454.             while(TickCount() == tc)
  455.                 /* loop */;
  456.             VidSync();
  457.             FrameRect(&rect);
  458.     
  459.             if (anchor.v < current.v)
  460.             {
  461.                 rect.top = anchor.v;
  462.                 rect.bottom = current.v;
  463.             }
  464.             else
  465.             {
  466.                 rect.top = current.v;
  467.                 rect.bottom = anchor.v;
  468.             }
  469.     
  470.             if (anchor.h < current.h)
  471.             {
  472.                 rect.left = anchor.h;
  473.                 rect.right = current.h;
  474.             }
  475.             else
  476.             {
  477.                 rect.right = anchor.h;
  478.                 rect.left = current.h;
  479.             }
  480.     
  481.             FrameRect(&rect);
  482.             last = current;
  483.         }
  484.     
  485.         FrameRect(&rect);
  486.  
  487.         PenPat(PATTERN(qd.black));    
  488.         PenMode(patCopy);
  489.  
  490.         if (!inSplash(&anchor,¤t))
  491.         {
  492.             x0 = (short) ((long) rect.left * RGMwind[i]->xscale / RGMwind[i]->width );
  493.             y0 = (short) (RGMwind[i]->yscale -
  494.                     (long) rect.top * RGMwind[i]->yscale / RGMwind[i]->height);
  495.             x1 = (short) ((long) rect.right * RGMwind[i]->xscale / RGMwind[i]->width);
  496.             y1 = (short) (RGMwind[i]->yscale -
  497.                     (long) rect.bottom * RGMwind[i]->yscale / RGMwind[i]->height);
  498.             x1 = (x1 < x0+2) ? x0 + 4 : x1;
  499.             y0 = (y0 < y1+2) ? y1 + 4 : y0;
  500.  
  501.             VGzoom( i,
  502.                     x0 + RGMwind[i]->xorigin,
  503.                     y1 + RGMwind[i]->yorigin,
  504.                     x1 + RGMwind[i]->xorigin,
  505.                     y0 + RGMwind[i]->yorigin);
  506.  
  507.             VGpage(RGMwind[i]->vg);
  508.  
  509.             RGMwind[i]->xscale  = x1 - x0;
  510.             RGMwind[i]->yscale  = y0 - y1;
  511.             RGMwind[i]->xorigin = x0 + RGMwind[i]->xorigin;
  512.             RGMwind[i]->yorigin = y1 + RGMwind[i]->yorigin;
  513.  
  514.             while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  515.                 Stask();
  516.             RGMlastclick = 0L;
  517.         }
  518.         else
  519.         {
  520.             if (RGMlastclick && ((RGMlastclick + GetDblTime()) > TickCount()))
  521.             {
  522.                 RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  523.                 RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  524.                 RGMwind[i]->xorigin = 0;
  525.                 RGMwind[i]->yorigin = 0;
  526.  
  527.                 VGzoom(i,0,0,WINXMAX-1,WINYMAX-1);    /* BYU LSC - need the "W" here */
  528.                 VGpage( RGMwind[i]->vg);
  529.                 while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  530.                     Stask();
  531.                 RGMlastclick = 0L;
  532.             }
  533.             else RGMlastclick = TickCount();
  534.         }
  535.         return;
  536.     
  537.     }
  538.     
  539.     /* NCSA: SB */
  540.     /* NCSA: SB - These computations are being truncated and turned into signed ints. */
  541.     /* NCSA: SB - Just make sure everything is cast correctly, and were fine */
  542.     
  543.     lx = ((unsigned long)RGMwind[i]->xscale * (unsigned long)where.h)     /* NCSA: SB */
  544.             / (unsigned long)RGMwind[i]->width;                             /* NCSA: SB */
  545.     ly = (unsigned long)RGMwind[i]->yscale -                             /* NCSA: SB */
  546.         ((unsigned long)RGMwind[i]->yscale * (unsigned long)where.v) / (unsigned long)RGMwind[i]->height; /* NCSA: SB */
  547.  
  548.     VGgindata(RGMwind[i]->vg,(unsigned short) lx,(unsigned short)ly,' ',thispaceforent);    /* NCSA: SB */
  549.  
  550. #if 0                                                    /* BYU LSC - not needed */
  551. sprintf(dum,"GIN i: %d, vs: %d\015",i,RGMwind[i]->vs);    /* BYU 2.4.18 - changed \n to \015 */
  552. putln(dum);
  553. #endif                                                    /* BYU LSC - not needed */
  554.  
  555.     RSsendstring(RGMwind[i]->vs,thispaceforent,5);
  556.     sprintf(dum," \r\n");
  557.     RSsendstring(RGMwind[i]->vs,dum,3);
  558.     
  559.  
  560.     /*    RGMwind[i]->ingin = 0; */
  561.     unsetgraphcurs();
  562.     RGMlastclick = TickCount();
  563. }
  564.  
  565.  
  566. /*--------------------------------------------------------------------------*/
  567. /* NCSA: SB - RGMgrowme                                                        */
  568. /* This allows the TEK window to be grown like any other real window.        */
  569. /* The grow box is not shown on the screen, but it acts accordingly     - SMB    */
  570. /*--------------------------------------------------------------------------*/
  571. void    RGMgrowme(short myRGMnum,GrafPtr window, long *where, short modifiers)
  572. {
  573.     UNUSED_ARG(modifiers)
  574.     long size;
  575.     Rect SizRect;
  576.  
  577.     SetRect(&SizRect, 50, 50, 1500, 1500);            /* NCSA: SB - max size - arbitrary */
  578.  
  579.     if (where)
  580.     {        
  581.         size = GrowWindow(window, *(Point *) where, &SizRect);    
  582.         if (size != 0L)
  583.             {
  584.             SizeWindow(window, size & 0xffff, (size >> 16) & 0xffff, FALSE);
  585.             RGMwind[myRGMnum]->width   = window->portRect.right - window->portRect.left;        
  586.             RGMwind[myRGMnum]->height  = window->portRect.bottom - window->portRect.top;         
  587.             VGpage(RGMwind[myRGMnum]->vg);
  588.             InvalRect(&window->portRect);
  589.             RGupdate(window);
  590.             }
  591.         else
  592.             return;                            /* user skipped growing */
  593.     }
  594. }
  595.  
  596.